home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gnuchess.lha / uxdsp.c < prev    next >
C/C++ Source or Header  |  1990-06-09  |  31KB  |  1,411 lines
  1. /* uxdsp.c - ALPHA interface for CHESS
  2.  
  3.   Revision: 1990-05-09
  4.  
  5.   Copyright (C) 1986, 1987, 1988, 1989, 1990 Free Software Foundation, Inc.
  6.   Copyright (c) 1988, 1989, 1990  John Stanback
  7.  
  8.   This file is part of CHESS.
  9.  
  10.   CHESS is distributed in the hope that it will be useful, but WITHOUT ANY
  11.   WARRANTY.  No author or distributor accepts responsibility to anyone for
  12.   the consequences of using it or for whether it serves any particular
  13.   purpose or works at all, unless he says so in writing.  Refer to the CHESS
  14.   General Public License for full details.
  15.  
  16.   Everyone is granted permission to copy, modify and redistribute CHESS, but
  17.   only under the conditions described in the CHESS General Public License.
  18.   A copy of this license is supposed to have been given to you along with
  19.   CHESS so you can know your rights and responsibilities.  It should be in a
  20.   file named COPYING.  Among other things, the copyright notice and this
  21.   notice must be preserved on all copies.
  22. */
  23.  
  24. #include <ctype.h>
  25. #include <signal.h>
  26. #ifdef MSDOS
  27. #include <dos.h>
  28. #include <conio.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  31. #include <time.h>
  32.  
  33. #define ESC 0x1B
  34. #define scanz scanf
  35. #define printz printf
  36. #define refresh() fflush(stdout)
  37.  
  38. int mycntl1, mycntl2;
  39. static void param (short n);
  40. #else
  41. #include <sys/param.h>
  42. #include <sys/types.h>
  43. #include <sys/file.h>
  44. #include <curses.h>
  45.  
  46. #define scanz fflush(stdout),scanw
  47. #define printz printw
  48.  
  49. /* <stdlib.h> */
  50. extern void *malloc (size_t);
  51. extern void exit (int);
  52. /* <string.h> */
  53. extern char *strcat (char *, const char *);
  54. extern int strcmp (const char *, const char *);
  55. extern char *strcpy (char *, const char *);
  56. /* <time.h> */
  57. extern long int time (long int *);
  58. #endif /* MSDOS */
  59.  
  60. #include "gnuchess.h"
  61.  
  62. #define pxx " PNBRQK"
  63. #define qxx " pnbrqk"
  64. #define rxx "12345678"
  65. #define cxx "abcdefgh"
  66. #define TAB (46)
  67. #define VIR_C(s)  ((flag.reverse) ? 7-column(s) : column(s))
  68. #define VIR_R(s)  ((flag.reverse) ? 7-row(s) : row(s))
  69.  
  70. static char mvstr[4][6];
  71. static char* ColorStr[2] = {"White", "Black"};
  72. static long evrate;
  73.  
  74. extern char *getenv (const char *);
  75. void TerminateSearch (int), Die (int);
  76.  
  77. void
  78. Initialize (void)
  79. {
  80.   signal (SIGINT, Die);
  81. #ifndef MSDOS
  82.   signal (SIGQUIT, Die);
  83.   initscr ();
  84.   crmode ();
  85. #else
  86.   mycntl1 = mycntl2 = 0;
  87. #endif /* MSDOS */
  88. }
  89.  
  90. void
  91. ExitChess (void)
  92. {
  93.   ListGame ();
  94.   gotoXY (1, 24);
  95. #ifndef MSDOS
  96.   nocrmode ();
  97.   endwin ();
  98. #endif /* MSDOS */
  99.   exit (0);
  100. }
  101.  
  102. void
  103. Die (int Sig)
  104. {
  105.   char s[80];
  106.  
  107.   signal (SIGINT, SIG_IGN);
  108. #ifdef MSDOS
  109.   Sig++;                /* shut up the compiler */
  110. #else
  111.   signal (SIGQUIT, SIG_IGN);
  112. #endif /* MSDOS */
  113.   ShowMessage ("Abort? ");
  114.   scanz ("%s", s);
  115.   if (strcmp (s, "yes") == 0)
  116.     ExitChess ();
  117.   signal (SIGINT, Die);
  118. #ifndef MSDOS
  119.   signal (SIGQUIT, Die);
  120. #endif /* MSDOS */
  121. }
  122.  
  123. void
  124. TerminateSearch (int Sig)
  125. {
  126.   signal (SIGINT, SIG_IGN);
  127. #ifdef MSDOS
  128.   Sig++;                /* shut up the compiler */
  129. #else
  130.   signal (SIGQUIT, SIG_IGN);
  131. #endif /* MSDOS */
  132.   flag.timeout = true;
  133.   flag.bothsides = false;
  134.   signal (SIGINT, Die);
  135. #ifndef MSDOS
  136.   signal (SIGQUIT, Die);
  137. #endif /* MSDOS */
  138. }
  139.  
  140. void
  141. algbr (short int f, short int t, short int flag)
  142.  
  143. /*
  144.    Generate move strings in different formats.
  145. */
  146.  
  147. {
  148.   int m3p;
  149.  
  150.   if (f != t)
  151.     {
  152.       /* algebraic notation */
  153.       mvstr[0][0] = cxx[column (f)];
  154.       mvstr[0][1] = rxx[row (f)];
  155.       mvstr[0][2] = cxx[column (t)];
  156.       mvstr[0][3] = rxx[row (t)];
  157.       mvstr[0][4] = mvstr[3][0] = '\0';
  158.       if ((mvstr[1][0] = pxx[board[f]]) == 'P')
  159.     {
  160.       if (mvstr[0][0] == mvstr[0][2])    /* pawn did not eat */
  161.         {
  162.           mvstr[2][0] = mvstr[1][0] = mvstr[0][2];    /* to column */
  163.           mvstr[2][1] = mvstr[1][1] = mvstr[0][3];    /* to row */
  164.           m3p = 2;
  165.         }
  166.       else
  167.         /* pawn ate */
  168.         {
  169.           mvstr[2][0] = mvstr[1][0] = mvstr[0][0];    /* from column */
  170.           mvstr[2][1] = mvstr[1][1] = mvstr[0][2];    /* to column */
  171.           mvstr[2][2] = mvstr[0][3];
  172.           m3p = 3;        /* to row */
  173.         }
  174.       mvstr[2][m3p] = mvstr[1][2] = '\0';
  175.       if (flag & promote)
  176.         {
  177.           mvstr[0][4] = mvstr[1][2] = mvstr[2][m3p] = qxx[flag & pmask];
  178.           mvstr[1][3] = mvstr[2][m3p + 1] = mvstr[0][5] = '\0';
  179.         }
  180.     }
  181.       else
  182.     /* not a pawn */
  183.     {
  184.       mvstr[2][0] = mvstr[1][0];
  185.       mvstr[2][1] = mvstr[0][1];
  186.       mvstr[2][2] = mvstr[1][1] = mvstr[0][2];    /* to column */
  187.       mvstr[2][3] = mvstr[1][2] = mvstr[0][3];    /* to row */
  188.       mvstr[2][4] = mvstr[1][3] = '\0';
  189.       strcpy (mvstr[3], mvstr[2]);
  190.       mvstr[3][1] = mvstr[0][0];
  191.       if (flag & cstlmask)
  192.         {
  193.           if (t > f)
  194.         {
  195.           strcpy (mvstr[1], "o-o");
  196.           strcpy (mvstr[2], "O-O");
  197.         }
  198.           else
  199.         {
  200.           strcpy (mvstr[1], "o-o-o");
  201.           strcpy (mvstr[2], "O-O-O");
  202.         }
  203.         }
  204.     }
  205.     }
  206.   else
  207.     mvstr[0][0] = mvstr[1][0] = mvstr[2][0] = mvstr[3][0] = '\0';
  208. }
  209.  
  210. int
  211. VerifyMove (char *s, short int iop, short unsigned int *mv)
  212.  
  213. /*
  214.    Compare the string 's' to the list of legal moves available for the
  215.    opponent. If a match is found, make the move on the board.
  216. */
  217.  
  218. {
  219.   static short pnt, tempb, tempc, tempsf, tempst, cnt;
  220.   static struct leaf xnode;
  221.   struct leaf *node;
  222.  
  223.   *mv = 0;
  224.   if (iop == 2)
  225.     {
  226.       UnmakeMove (opponent, &xnode, &tempb, &tempc, &tempsf, &tempst);
  227.       return (false);
  228.     }
  229.   cnt = 0;
  230.   MoveList (opponent, 2);
  231.   pnt = TrPnt[2];
  232.   while (pnt < TrPnt[3])
  233.     {
  234.       node = &Tree[pnt++];
  235.       algbr (node->f, node->t, (short) node->flags);
  236.       if (strcmp (s, mvstr[0]) == 0 || strcmp (s, mvstr[1]) == 0 ||
  237.       strcmp (s, mvstr[2]) == 0 || strcmp (s, mvstr[3]) == 0)
  238.     {
  239.       cnt++;
  240.       xnode = *node;
  241.     }
  242.     }
  243.   if (cnt == 1)
  244.     {
  245.       MakeMove (opponent, &xnode, &tempb, &tempc, &tempsf, &tempst, &INCscore);
  246.       if (SqAtakd (PieceList[opponent][0], computer))
  247.     {
  248.       UnmakeMove (opponent, &xnode, &tempb, &tempc, &tempsf, &tempst);
  249.       ShowMessage ("Illegal Move!!");
  250.       return (false);
  251.     }
  252.       else
  253.     {
  254.       if (iop == 1)
  255.         return (true);
  256.       UpdateDisplay (xnode.f, xnode.t, 0, (short) xnode.flags);
  257.       if ((board[xnode.t] == pawn)
  258.           || (xnode.flags & capture)
  259.           || (xnode.flags & cstlmask))
  260.         {
  261.           Game50 = GameCnt;
  262.           ZeroRPT ();
  263.         }
  264.       GameList[GameCnt].depth = GameList[GameCnt].score = 0;
  265.       GameList[GameCnt].nodes = 0;
  266.       ElapsedTime (1);
  267.       GameList[GameCnt].time = (short) et;
  268.       TimeControl.clock[opponent] -= et;
  269.       --TimeControl.moves[opponent];
  270.       *mv = (xnode.f << 8) | xnode.t;
  271.       algbr (xnode.f, xnode.t, false);
  272.       return (true);
  273.     }
  274.     }
  275.   if (cnt > 1)
  276.     ShowMessage ("Ambiguous Move!");
  277.   return (false);
  278. }
  279.  
  280. void
  281. help (void)
  282. {
  283.   ClrScreen ();
  284.   printz ("CHESS command summary\n");
  285.   printz ("g1f3     move from g1 to f3      quit      Exit Chess\n");
  286.   printz ("Nf3      move knight to f3       beep      on/off\n");
  287.   printz ("o-o      castle king side        easy      on/off\n");
  288.   printz ("o-o-o    castle queen side       hash      on/off\n");
  289.   printz ("bd       redraw board            reverse   board display\n");
  290.   printz ("list     game to chess.lst       book      on/off\n");
  291.   printz ("undo     undo last ply           remove    take back a move\n");
  292.   printz ("edit     edit board              force     enter game moves\n");
  293.   printz ("switch   sides with computer     both      computer match\n");
  294.   printz ("white    computer plays white    black     computer plays black\n");
  295.   printz ("depth    set search depth        level     select level\n");
  296.   printz ("post     principle variation     hint      suggest a move\n");
  297.   printz ("save     game to file            get       game from file\n");
  298.   printz ("random   randomize play          new       start new game\n");
  299.   printz ("rv       toggle reverse video    coords    toggle coords\n");
  300.   printz ("shade    toggle shade black      stars     toggle stars\n");
  301.   printz ("p        show coordinate values\n");
  302.   gotoXY (10, 21);
  303.   printz ("Computer: %s", ColorStr[computer]);
  304.   gotoXY (10, 22);
  305.   printz ("Opponent: %s", ColorStr[opponent]);
  306.   gotoXY (10, 23);
  307.   printz ("Level: %ld", Level);
  308.   gotoXY (10, 24);
  309.   printz ("Easy mode: %s", (flag.easy) ? "ON" : "OFF");
  310.   gotoXY (40, 21);
  311.   printz ("Depth: %d", MaxSearchDepth);
  312.   gotoXY (40, 22);
  313.   printz ("Random: %s", (dither) ? "ON" : "OFF");
  314.   gotoXY (40, 23);
  315.   printz ("Transposition table: %s", (flag.hash) ? "ON" : "OFF");
  316.   gotoXY (40, 24);
  317.   printz ("Hit <RET> to return: ");
  318.   refresh ();
  319.   fflush(stdin);
  320.   getchar();
  321.   ClrScreen ();
  322.   UpdateDisplay (0, 0, 1, 0);
  323. }
  324.  
  325. void
  326. EditBoard (void)
  327.  
  328. /*
  329.   Set up a board position. Pieces are entered by typing the piece
  330.   followed by the location. For example, Nf3 will place a knight on
  331.   square f3.
  332. */
  333.  
  334. {
  335.   short a, r, c, sq, i;
  336.   char s[80];
  337.  
  338.   ClrScreen ();
  339.   UpdateDisplay (0, 0, 1, 0);
  340.   gotoXY (TAB, 3);
  341.   printz (".   Exit to main");
  342.   gotoXY (TAB, 4);
  343.   printz ("#   Clear board");
  344.   gotoXY (TAB, 5);
  345.   printz ("c   Change sides");
  346.   gotoXY (TAB, 7);
  347.   printz ("Enter piece & location: ");
  348.   a = white;
  349.   do
  350.     {
  351.       gotoXY (TAB, 6);
  352.       printz ("Editing: %s", ColorStr[a]);
  353.       gotoXY (TAB + 24, 7);
  354.       ClrEoln ();
  355.       scanz ("%s", s);
  356.       if (s[0] == '#')
  357.     {
  358.       for(sq = 0; sq < 64; sq++)
  359.         {
  360.           board[sq] = no_piece;
  361.           color[sq] = neutral;
  362.           DrawPiece (sq);
  363.         }
  364.     }
  365.       if (s[0] == 'c' || s[0] == 'C')
  366.     a = otherside[a];
  367.       c = s[1] - 'a';
  368.       r = s[2] - '1';
  369.       if ((c >= 0) && (c < 8) && (r >= 0) && (r < 8))
  370.     {
  371.       sq = locn (r, c);
  372.       for (i = king; i > no_piece; i--)
  373.         if ((s[0] == pxx[i]) || (s[0] == qxx[i]))
  374.           break;
  375.       board[sq] = i;
  376.       color[sq] = (board[sq] == no_piece) ? neutral : a;    
  377.       DrawPiece (sq);
  378.     }
  379.   } while (s[0] != '.');
  380.  
  381.   for (sq = 0; sq < 64; sq++)
  382.     Mvboard[sq] = (board[sq] != Stboard[sq]) ? 10 : 0;
  383.   GameCnt = 0;
  384.   Game50 = 1;
  385.   ZeroRPT ();
  386.   Sdepth = 0;
  387.   InitializeStats ();
  388.   ClrScreen ();
  389.   UpdateDisplay (0, 0, 1, 0);
  390. }
  391.  
  392. void
  393. ShowPlayers (void)
  394. {      
  395.   gotoXY (5, ((flag.reverse) ? 23 : 2));
  396.   printz ("%s", (computer == black) ? "Computer" : "Human   ");
  397.   gotoXY (5, ((flag.reverse) ? 2 : 23));
  398.   printz ("%s", (computer == white) ? "Computer" : "Human   ");
  399. }
  400.  
  401. void
  402. ShowDepth (char ch)
  403. {
  404.   gotoXY (TAB, 4);
  405.   printz ("Depth= %d%c ", Sdepth, ch);
  406.   ClrEoln ();
  407. }
  408.  
  409. void
  410. ShowScore (short score)
  411. {
  412.   gotoXY (TAB, 5);
  413.   printz ("Score= %d", score);
  414.   ClrEoln ();
  415. }
  416.  
  417. void
  418. ShowMessage (char *s)
  419. {
  420.   gotoXY (TAB, 6);
  421.   printz ("%s", s);
  422.   ClrEoln ();
  423. }
  424.  
  425. void
  426. ClearMessage (void)
  427. {
  428.   gotoXY (TAB, 6);
  429.   ClrEoln ();
  430. }
  431.  
  432. void
  433. ShowCurrentMove (short int pnt, short int f, short int t)
  434. {
  435.   algbr (f, t, false);
  436.   gotoXY (TAB, 7);
  437.   printz ("(%2d) %4s", pnt, mvstr[0]);
  438. }
  439.  
  440. void
  441. ShowHeader (void)
  442. {
  443.   gotoXY (TAB, 2);
  444.   printz ("GNU Chess");
  445. }
  446.  
  447. void
  448. ShowSidetomove (void)
  449. {
  450.   gotoXY (TAB, 14);
  451.   printz ("%2d:   %s", 1 + GameCnt / 2, ColorStr[player]);
  452.   ClrEoln ();
  453. }
  454.  
  455. void
  456. ShowPrompt (void)
  457. {
  458.   gotoXY (TAB, 19);
  459.   printz ("Your move is? ");
  460.   ClrEoln ();
  461. }
  462.  
  463. void
  464. ShowNodeCnt (long int NodeCnt, long int evrate)
  465. {      
  466.   gotoXY (TAB, 21);
  467.   printz ("Nodes= %8ld, Nodes/Sec= %5ld", NodeCnt, evrate);
  468.   ClrEoln ();
  469. }  
  470.  
  471. void
  472. ShowResults (short int score, short unsigned int *bstline, char ch)
  473. {
  474.   unsigned char d, ply;
  475.   if (flag.post)
  476.     {
  477.       ShowDepth (ch);
  478.       ShowScore (score);
  479.       d = 7;
  480.       for (ply = 1; bstline[ply] > 0; ply++)
  481.     {
  482.       if (ply % 4 == 1)
  483.         {
  484.           gotoXY (TAB, ++d);
  485.           ClrEoln ();
  486.         }
  487.       algbr ((short) bstline[ply] >> 8, (short) bstline[ply] & 0xFF, false);
  488.       printz ("%5s ", mvstr[0]);
  489.     }
  490.       ClrEoln ();    
  491.       while (d < 13)
  492.     {
  493.       gotoXY (TAB, ++d);
  494.       ClrEoln ();
  495.     }
  496.     }
  497. }
  498.  
  499. void
  500. SearchStartStuff (short int side)
  501. {
  502.   short i;
  503.   
  504.   signal (SIGINT, TerminateSearch);
  505. #ifdef MSDOS
  506.   side++;                /* shut up the compiler */
  507. #else
  508.   signal (SIGQUIT, TerminateSearch);
  509. #endif /* MSDOS */
  510.   for (i = 4; i < 14; i++)
  511.     {
  512.       gotoXY (TAB, i);
  513.       ClrEoln ();
  514.     }
  515. }
  516.  
  517. void
  518. OutputMove (void)
  519. {
  520.   int i;
  521.  
  522.   UpdateDisplay (root->f, root->t, 0, (short) root->flags);
  523.   gotoXY (TAB, 17);
  524.   printz ("My move is: %s", mvstr[0]);
  525.   if (flag.beep)
  526.     putchar (7);
  527.   ClrEoln ();
  528.  
  529.   gotoXY (TAB, 24);
  530.   if (root->flags & draw)
  531.     printz ("Drawn game!");
  532.   else if (root->score == -9999)
  533.     printz ("Opponent mates!");
  534.   else if (root->score == 9998)
  535.     printz ("Computer mates!");
  536.   else if (root->score < -9000)
  537.     printz ("Opponent will soon mate!");
  538.   else if (root->score > 9000)
  539.     printz ("Computer will soon mate!");
  540.   ClrEoln ();
  541.  
  542.   if (flag.post)
  543.     {
  544.       ShowNodeCnt (NodeCnt, evrate);
  545.       gotoXY (TAB, 22);
  546.       for (i = 1999; i >= 0 && Tree[i].f == 0 && Tree[i].t == 0; i--);
  547.       printz ("Max Tree= %5d", i);
  548.       ClrEoln ();
  549.     }
  550. }
  551.  
  552. void
  553. ElapsedTime (short int iop)
  554.  
  555. /*
  556.   Determine the time that has passed since the search was started. If
  557.   the elapsed time exceeds the target (ResponseTime+ExtraTime) then set
  558.   timeout to true which will terminate the search.
  559. */
  560.              
  561. {
  562.   et = time ((long *) 0) - time0;
  563.   if (et < 0)
  564.     et = 0;
  565.   ETnodes += 50;
  566.   if (et > et0 || iop == 1)
  567.     {
  568.       if (et > ResponseTime + ExtraTime && Sdepth > 1)
  569.     flag.timeout = true;
  570.       et0 = et;
  571.       if (iop == 1)
  572.     {
  573.       time0 = time ((long *) 0);
  574.       et0 = 0;
  575.     }
  576.       if (et > 0)
  577.     /* evrate used to be Nodes / cputime I dont` know why */
  578.     evrate = NodeCnt / (et + ft);
  579.       else
  580.     evrate = 0;
  581.       ETnodes = NodeCnt + 50;
  582.       UpdateClocks ();
  583.     }
  584. }
  585.  
  586. void
  587. UpdateClocks (void)
  588. {
  589.   short m, s;
  590.   m = (short) (et / 60);
  591.   s = (short) (et - 60 * (long) m);
  592.   if (TCflag)
  593.     {
  594.       m = (short) ((TimeControl.clock[player] - et) / 60);
  595.       s = (short) (TimeControl.clock[player] - et - 60 * (long) m);
  596.     }
  597.   if (m < 0)
  598.     m = 0;
  599.   if (s < 0)
  600.     s = 0;
  601.   if (player == white)
  602.     gotoXY (20, (flag.reverse) ? 2 : 23);
  603.   else
  604.     gotoXY (20, (flag.reverse) ? 23 : 2);
  605.   printz ("%d:%2d   ", m, s);
  606.   if (flag.post)
  607.     ShowNodeCnt (NodeCnt, evrate);
  608.   refresh ();
  609. }
  610.  
  611. void
  612. SetTimeControl (void)
  613. {
  614.   if (TCflag)
  615.     {
  616.       TimeControl.moves[white] = TimeControl.moves[black] = TCmoves;
  617.       TimeControl.clock[white] = TimeControl.clock[black] = 60 * (long) TCminutes;
  618.     }
  619.   else
  620.     {
  621.       TimeControl.moves[white] = TimeControl.moves[black] = 0;
  622.       TimeControl.clock[white] = TimeControl.clock[black] = 0;
  623.       Level = 60 * (long) TCminutes;
  624.     }
  625.   et = 0;
  626.   ElapsedTime (1);
  627. }
  628.  
  629. void
  630. gotoXY (short int x, short int y)
  631. {
  632. #ifdef MSDOS
  633.   putchar(ESC);
  634.   putchar('[');
  635.   param(y);
  636.   putchar(';');
  637.   param(x);
  638.   putchar('H');
  639. #else
  640.   move (y - 1, x - 1);
  641. #endif /* MSDOS */
  642. }
  643.  
  644. void
  645. ClrScreen (void)
  646. {
  647. #ifdef MSDOS
  648.   putchar(ESC);
  649.   putchar('[');
  650.   putchar('2');
  651.   putchar('J');
  652. #else
  653.   clear ();
  654. #endif /* MSDOS */
  655.   refresh ();
  656. }
  657.  
  658. void
  659. ClrEoln (void)
  660. {
  661. #ifdef MSDOS
  662.   putchar(ESC);
  663.   putchar('[');
  664.   putchar('K');
  665. #else
  666.   clrtoeol ();
  667. #endif /* MSDOS */
  668.   refresh ();
  669. }
  670.  
  671. #ifdef MSDOS
  672. void
  673. param(short n)
  674. {
  675.   if (n >= 10)
  676.     {
  677.     register short d, q;
  678.     q = n/10; d = n%10;
  679.     putchar(q + '0');
  680.     putchar(d + '0');
  681.   }
  682.   else
  683.     putchar(n + '0');
  684. }
  685. #endif /* MSDOS */
  686.  
  687. void
  688. DrawPiece (short int sq)
  689. {
  690.   register char x;
  691.   
  692.   if (color[sq] == black)
  693. #if defined(MSDOS) && !defined(SEVENBIT)
  694.     x = '7';                /* print WHITE boldface, */
  695.   else
  696.     x = '1';                /* print BLACK inverted     */
  697.   gotoXY (6 + 5 * VIR_C(sq), 5 + 2 * (7 - VIR_R(sq)));
  698.   printz ("\033[%cm%c\033[0m", x, pxx[board[sq]]);
  699. #else
  700.     x = '*';
  701.   else
  702.     x = ' ';
  703.   gotoXY (5 + 5 * VIR_C(sq), 5 + 2 * (7 - VIR_R(sq)));
  704.   printz ("%c%c ", x, pxx[board[sq]]);
  705. #endif /* MSDOS && !SEVENBIT */
  706. }
  707.  
  708. void
  709. ShowPostnValue (short int sq)
  710.  
  711. /*
  712.   must have called ExaminePosition() first
  713. */
  714.      
  715. {
  716.   short score;
  717.       
  718.   gotoXY (4 + 5 * VIR_C(sq), 5 + 2 * (7 - VIR_R(sq)));
  719.   ScorePosition(color[sq], &score);
  720.   if (color[sq] != neutral)
  721.     printz ("%3d ", svalue[sq]);
  722.   else
  723.     printz ("   ");
  724. }
  725.  
  726. void
  727. ShowPostnValues (void)
  728. {
  729.   short sq, score;
  730.  
  731.   ExaminePosition ();
  732.   for (sq = 0; sq < 64; sq++)
  733.     ShowPostnValue (sq);
  734.   ScorePosition (opponent, &score);
  735.   ShowScore (score);
  736. }
  737.  
  738. void
  739. UpdateDisplay (short int f, short int t, short int redraw, short int isspec)
  740. {
  741.   short i, sq, z;
  742.   
  743.   if (redraw)
  744.     {
  745.       ShowHeader ();
  746.       ShowPlayers ();
  747.  
  748.       i = 3;
  749.       gotoXY (3, ++i);
  750. #if defined(MSDOS) && !defined(SEVENBIT)
  751.       printz ("\332\304\304\304\304\302\304\304\304\304\302\304\304\304\304"\
  752.               "\302\304\304\304\304\302\304\304\304\304\302\304\304\304\304"\
  753.               "\302\304\304\304\304\302\304\304\304\304\277");
  754. #else
  755.       printz ("+----+----+----+----+----+----+----+----+");
  756. #endif /* MSDOS && !SEVENBIT */
  757.       while (i < 19)
  758.     {
  759.       gotoXY (1, ++i);
  760.       if (flag.reverse)
  761.         z = (i / 2) - 1;
  762.       else
  763.         z = 10 - (i / 2);
  764. #if defined(MSDOS) && !defined(SEVENBIT)
  765.           printz ("%d \263    \263    \263    \263    \263    \263    "\
  766.           "\263    \263    \263",z);
  767. #else
  768.           printz ("%d |    |    |    |    |    |    |    |    |",z);
  769. #endif /* MSDOS && !SEVENBIT */
  770.       gotoXY (3, ++i);
  771.       if (i < 19)
  772. #if defined(MSDOS) && !defined(SEVENBIT)
  773.         printz ("\303\304\304\304\304\305\304\304\304\304\305\304\304"\
  774.             "\304\304\305\304\304\304\304\305\304\304\304\304\305"\
  775.             "\304\304\304\304\305\304\304\304\304\305\304\304\304"\
  776.             "\304\264");
  777. #else
  778.             printz ("+----+----+----+----+----+----+----+----+");
  779. #endif /* MSDOS && !SEVENBIT */
  780.     }
  781. #if defined(MSDOS) && !defined(SEVENBIT)
  782.       printz ("\300\304\304\304\304\301\304\304\304\304\301\304\304\304\304"\
  783.               "\301\304\304\304\304\301\304\304\304\304\301\304\304\304\304"\
  784.               "\301\304\304\304\304\301\304\304\304\304\331");
  785. #else
  786.       printz ("+----+----+----+----+----+----+----+----+");
  787. #endif /* MSDOS && !SEVENBIT */
  788.       gotoXY (3, 21);
  789.       if (flag.reverse)
  790.     printz ("  h    g    f    e    d    c    b    a");
  791.       else
  792.     printz ("  a    b    c    d    e    f    g    h");
  793.       for (sq = 0; sq < 64; sq++)
  794.     DrawPiece (sq);
  795.     }
  796.   else
  797.     {
  798.       DrawPiece (f);
  799.       DrawPiece (t);
  800.       if (isspec & cstlmask)
  801.     if (t > f)
  802.       {
  803.         DrawPiece (f + 3);
  804.         DrawPiece (t - 1);
  805.       }
  806.     else
  807.       {
  808.         DrawPiece (f - 4);
  809.         DrawPiece (t + 1);
  810.       }
  811.       else if (isspec & epmask)
  812.     {
  813.       DrawPiece (t - 8);
  814.       DrawPiece (t + 8);
  815.     }
  816.     }
  817.   refresh ();
  818. }
  819.  
  820. void
  821. GetGame (void)
  822. {
  823.   FILE *fd;
  824.   char fname[256], tname[256];
  825.   char *tmp;
  826.   int c;
  827.   short sq;
  828.   unsigned short m;
  829.  
  830.   tname[0] = 0;
  831.  
  832.   if (tmp = getenv ("HOME"))
  833.     strcpy (fname, tmp);
  834.   else
  835.     fname[0] = '\0';
  836.   strcat (fname, "/");
  837.  
  838.   ShowMessage ("File name: ");
  839.   scanz ("%s", tname);
  840.  
  841.   if (tname[0])
  842.     strcat (fname, tname);
  843.   else
  844.     strcat (fname, "chess.000");
  845.  
  846.   ShowMessage("Loading ");
  847.   printz ("%s", fname);
  848.  
  849.   if ((fd = fopen (fname, "r")) == NULL)
  850.     {
  851.       ShowMessage ("Load failed");
  852.       return;
  853.     }
  854.  
  855.   fscanf (fd, "%hd%hd%hd", &computer, &opponent, &Game50);
  856.   fscanf (fd, "%hd%hd", &castld[white], &castld[black]);
  857.   fscanf (fd, "%hd%hd", &TCflag, &OperatorTime);
  858.   fscanf (fd, "%ld%ld%hd%hd",
  859.       &TimeControl.clock[white], &TimeControl.clock[black],
  860.       &TimeControl.moves[white], &TimeControl.moves[black]);
  861.   for (sq = 0; sq < 64; sq++)
  862.     {
  863.       fscanf (fd, "%hd%hd", &m, &Mvboard[sq]);
  864.       board[sq] = (m >> 8);
  865.       color[sq] = (m & 0xFF);
  866.       if (color[sq] == 0)
  867.     color[sq] = neutral;
  868.       else
  869.     --color[sq];
  870.     }
  871.   GameCnt = 0;
  872.   c = '?';
  873.   while (c != EOF)
  874.     {
  875.       ++GameCnt;
  876.       c = fscanf (fd, "%hd%hd%hd%ld%hd%hd%hd", &GameList[GameCnt].gmove,
  877.           &GameList[GameCnt].score, &GameList[GameCnt].depth,
  878.           &GameList[GameCnt].nodes, &GameList[GameCnt].time,
  879.           &GameList[GameCnt].piece, &GameList[GameCnt].color);
  880.       if (GameList[GameCnt].color == 0)
  881.     GameList[GameCnt].color = neutral;
  882.       else
  883.     --GameList[GameCnt].color;
  884.     }
  885.   GameCnt--;
  886.   if (TimeControl.clock[white] > 0)
  887.     TCflag = true;
  888.   computer--;
  889.   opponent--;
  890.  
  891.   fclose (fd);
  892.  
  893.   InitializeStats ();
  894.   Sdepth = 0;
  895.   ShowMessage ("Load done.  Press <Ret>");
  896.   fflush (stdin);
  897.   getchar ();
  898.   UpdateDisplay (0, 0, 1, 0);
  899.  
  900. }
  901.  
  902. void
  903. SaveGame (void)
  904. {
  905.   FILE *fd;
  906.   char fname[256], tname[256];
  907.   char *tmp;
  908.   short sq, i, c;
  909.  
  910.   tname[0] = 0;
  911.  
  912.   if (tmp = getenv ("HOME"))
  913.     strcpy (fname, tmp);
  914.   else
  915.     fname[0] = '\0';
  916.   strcat (fname, "/");
  917.  
  918.   ShowMessage ("File name: ");
  919.   refresh ();
  920.   scanz ("%s", tname);
  921.  
  922.   if (tname[0])
  923.     strcat (fname, tname);
  924.   else
  925.     strcat (fname, "chess.000");
  926.  
  927.   ShowMessage("Saving ");
  928.   printz ("%s", fname);
  929.  
  930.   if (NULL == (fd = fopen (fname, "w")))
  931.     {
  932.       ShowMessage ("Not saved");
  933.       return;
  934.     }
  935.  
  936.   fprintf (fd, "%d %d %d\n", computer + 1, opponent + 1, Game50);
  937.   fprintf (fd, "%d %d\n", castld[white], castld[black]);
  938.   fprintf (fd, "%d %d\n", TCflag, OperatorTime);
  939.   fprintf (fd, "%ld %ld %d %d\n",
  940.        TimeControl.clock[white], TimeControl.clock[black],
  941.        TimeControl.moves[white], TimeControl.moves[black]);
  942.   for (sq = 0; sq < 64; sq++)
  943.     {
  944.       if (color[sq] == neutral)
  945.     c = 0;
  946.       else
  947.     c = color[sq] + 1;
  948.       fprintf (fd, "%d %d\n", 256 * board[sq] + c, Mvboard[sq]);
  949.     }
  950.   for (i = 1; i <= GameCnt; i++)
  951.     {
  952.       if (GameList[i].color == neutral)
  953.     c = 0;
  954.       else
  955.     c = GameList[i].color + 1;
  956.       fprintf (fd, "%d %d %d %ld %d %d %d\n",
  957.            GameList[i].gmove, GameList[i].score, GameList[i].depth,
  958.            GameList[i].nodes, GameList[i].time,
  959.            GameList[i].piece, c);
  960.     }
  961.   fclose (fd);
  962.   ShowMessage ("Save done.  Press <Ret>");
  963.   fflush (stdin);
  964.   getchar ();
  965. }
  966.  
  967. void
  968. ListGame (void)
  969. {
  970.   FILE *fd;
  971.   char fname[256];
  972.   char *tmp;
  973.   short i, f, t;
  974.  
  975.   if (tmp = getenv ("HOME"))
  976.     strcpy (fname, tmp);
  977.   else
  978.     fname[0] = '\0';
  979.   strcat (fname, "/chess.lst");
  980.  
  981.   if (fd = fopen (fname, "w"))
  982.     ShowMessage ("Writing ~/chess.lst");
  983.   else
  984.     {
  985.       ShowMessage ("Cannot write ~/chess.lst");
  986.       return;
  987.     }
  988.  
  989.   fprintf (fd, "\n");
  990.   fprintf (fd, "       score  depth   nodes  time         ");
  991.   fprintf (fd, "       score  depth   nodes  time\n");
  992.   for (i = 1; i <= GameCnt; i++)
  993.     {
  994.       f = GameList[i].gmove >> 8;
  995.       t = (GameList[i].gmove & 0xFF);
  996.       algbr (f, t, false);
  997.       if ((i % 2) == 0)
  998.     fprintf (fd, "\n");
  999.       else
  1000.     fprintf (fd, "         ");
  1001.       fprintf (fd, "%5s  %5d     %2d %7ld %5d", mvstr[0],
  1002.            GameList[i].score, GameList[i].depth,
  1003.            GameList[i].nodes, GameList[i].time);
  1004.     }
  1005.   fprintf (fd, "\n\n");
  1006.   fclose (fd);
  1007.   ShowMessage ("~/chess.lst written");
  1008. }
  1009.  
  1010. void
  1011. Undo (void)
  1012.  
  1013. /*
  1014.   Undo the most recent half-move.
  1015. */
  1016.  
  1017. {
  1018.   short f, t;
  1019.   f = GameList[GameCnt].gmove >> 8;
  1020.   t = GameList[GameCnt].gmove & 0xFF;
  1021.   if (board[t] == king && distance (t, f) > 1)
  1022.     (void) castle (GameList[GameCnt].color, f, t, 2);
  1023.   else
  1024.     {
  1025.       /* Check for promotion: */
  1026.       if ((color[t] == white && row (f) == 6 && row (t) == 7)
  1027.       || (color[t] == black && row (f) == 1 && row (t) == 0))
  1028.     {
  1029.       int g, from = f;
  1030.       for (g = GameCnt - 1; g > 0; g--)
  1031.         if (GameList[g].gmove & 0xFF == from)
  1032.           from = GameList[g].gmove >> 8;
  1033.       if ((color[t] == white && row (from) == 1)
  1034.           || (color[t] == black && row (from) == 6))
  1035.         board[t] = pawn;
  1036.     }
  1037.       board[f] = board[t];
  1038.       color[f] = color[t];
  1039.       board[t] = GameList[GameCnt].piece;
  1040.       color[t] = GameList[GameCnt].color;
  1041.       if (color[t] != neutral)
  1042.     Mvboard[t]--;
  1043.       Mvboard[f]--;
  1044.     }
  1045.   if (TCflag)
  1046.     ++TimeControl.moves[color[f]];
  1047.   GameCnt--;
  1048.   computer = otherside[computer];
  1049.   opponent = otherside[opponent];
  1050.   flag.mate = false;
  1051.   Sdepth = 0;
  1052.   UpdateDisplay (0, 0, 1, 0);
  1053.   InitializeStats ();
  1054. }
  1055.  
  1056. void
  1057. ChangeAlphaWindow (void)
  1058. {
  1059.   ShowMessage ("Awindow= ");
  1060.   scanz ("%hd", &Awindow);
  1061. }
  1062.  
  1063. void
  1064. ChangeBetaWindow (void)
  1065. {
  1066.   ShowMessage ("Bwindow= ");
  1067.   scanz ("%hd", &Bwindow);
  1068. }
  1069.  
  1070. void
  1071. GiveHint (void)
  1072. {
  1073.   char s[40];
  1074.   algbr ((short) (hint >> 8), (short) (hint & 0xFF), false);
  1075.   strcpy (s, "try ");
  1076.   strcat (s, mvstr[0]);
  1077.   ShowMessage (s);
  1078. }
  1079.  
  1080. void
  1081. ChangeSearchDepth (void)
  1082. {
  1083.   ShowMessage ("depth= ");
  1084.   scanz ("%hd", &MaxSearchDepth);
  1085. }
  1086.  
  1087. void
  1088. SetContempt (void)
  1089. {
  1090.   ShowMessage ("contempt= ");
  1091.   scanz ("%hd", &contempt);
  1092. }
  1093.  
  1094. void
  1095. ChangeXwindow (void)
  1096. {
  1097.   ShowMessage ("xwndw= ");
  1098.   scanz ("%hd", &xwndw);
  1099. }
  1100.  
  1101. void
  1102. SelectLevel (void)
  1103. {
  1104.   ClrScreen ();
  1105.   gotoXY (32, 2);
  1106.   printz ("CHESS");
  1107.   gotoXY (20, 4);
  1108.   printz (" 1.   60 moves in   5 minutes");
  1109.   gotoXY (20, 5);
  1110.   printz (" 2.   60 moves in  15 minutes");
  1111.   gotoXY (20, 6);
  1112.   printz (" 3.   60 moves in  30 minutes");
  1113.   gotoXY (20, 7);
  1114.   printz (" 4.   40 moves in  30 minutes");
  1115.   gotoXY (20, 8);
  1116.   printz (" 5.   40 moves in  60 minutes");
  1117.   gotoXY (20, 9);
  1118.   printz (" 6.   40 moves in 120 minutes");
  1119.   gotoXY (20, 10);
  1120.   printz (" 7.   40 moves in 240 minutes");
  1121.   gotoXY (20, 11);
  1122.   printz (" 8.    1 move  in  15 minutes");
  1123.   gotoXY (20, 12);
  1124.   printz (" 9.    1 move  in  60 minutes");
  1125.   gotoXY (20, 13);
  1126.   printz ("10.    1 move  in 600 minutes");
  1127.  
  1128.   OperatorTime = 1;
  1129.   TCmoves = 60;
  1130.   TCminutes = 5;
  1131.  
  1132.   gotoXY (20, 17);
  1133.   printz ("Enter Level: ");
  1134.   refresh ();
  1135.   scanz ("%ld", &Level);
  1136.   switch ((int) Level)
  1137.     {
  1138.     case 1:
  1139.       TCmoves = 60;
  1140.       TCminutes = 5;
  1141.       break;
  1142.     case 2:
  1143.       TCmoves = 60;
  1144.       TCminutes = 15;
  1145.       break;
  1146.     case 3:
  1147.       TCmoves = 60;
  1148.       TCminutes = 30;
  1149.       break;
  1150.     case 4:
  1151.       TCmoves = 40;
  1152.       TCminutes = 30;
  1153.       break;
  1154.     case 5:
  1155.       TCmoves = 40;
  1156.       TCminutes = 60;
  1157.       break;
  1158.     case 6:
  1159.       TCmoves = 40;
  1160.       TCminutes = 120;
  1161.       break;
  1162.     case 7:
  1163.       TCmoves = 40;
  1164.       TCminutes = 240;
  1165.       break;
  1166.     case 8:
  1167.       TCmoves = 1;
  1168.       TCminutes = 15;
  1169.       break;
  1170.     case 9:
  1171.       TCmoves = 1;
  1172.       TCminutes = 60;
  1173.       break;
  1174.     case 10:
  1175.       TCmoves = 1;
  1176.       TCminutes = 600;
  1177.       break;
  1178.     }
  1179.  
  1180.   TCflag = (TCmoves > 1);
  1181.   SetTimeControl ();
  1182.   ClrScreen ();
  1183.   UpdateDisplay (0, 0, 1, 0);
  1184. }
  1185.  
  1186. void
  1187. DoDebug (void)
  1188. {
  1189.   short c, p, sq, tp, tc, tsq, score;
  1190.   char s[40];
  1191.   
  1192.   ExaminePosition ();
  1193.   ShowMessage ("Enter piece: ");
  1194.   scanz ("%s", s);
  1195.   c = neutral;
  1196.   if (s[0] == 'w' || s[0] == 'W')
  1197.     c = white;
  1198.   if (s[0] == 'b' || s[0] == 'B')
  1199.     c = black;
  1200.   for(p = king; p > no_piece; p--)
  1201.     if ((s[1] == pxx[p]) || (s[1] == qxx[p]))
  1202.       break;
  1203.   for (sq = 0; sq < 64; sq++)
  1204.     {
  1205.       tp = board[sq];
  1206.       tc = color[sq];
  1207.       board[sq] = p;
  1208.       color[sq] = c;
  1209.       tsq = PieceList[c][1];
  1210.       PieceList[c][1] = sq;
  1211.       ShowPostnValue (sq);
  1212.       PieceList[c][1] = tsq;
  1213.       board[sq] = tp;
  1214.       color[sq] = tc;
  1215.     }
  1216.   ScorePosition (opponent, &score);
  1217.   ShowScore (score);
  1218. }
  1219.  
  1220. void
  1221. TestSpeed(void (*f) (short int side, short int ply))
  1222. {
  1223.   short i;
  1224.   long t1, t2;
  1225.  
  1226.   t1 = time (0);
  1227.   for (i = 0; i < 10000; i++)
  1228.     {
  1229.       f (opponent, 2);
  1230.     }
  1231.   t2 = time (0);
  1232.   NodeCnt = 10000L * (TrPnt[3] - TrPnt[2]);
  1233.   evrate = NodeCnt / (t2 - t1);
  1234.   ShowNodeCnt (NodeCnt, evrate);
  1235. }
  1236.  
  1237. void
  1238. InputCommand (void)
  1239.  
  1240. /*
  1241.   Process the users command. If easy mode is OFF (the computer is thinking
  1242.   on opponents time) and the program is out of book, then make the 'hint'
  1243.   move on the board and call SelectMove() to find a response. The user
  1244.   terminates the search by entering ^C (quit siqnal) before entering a
  1245.   command. If the opponent does not make the hint move, then set Sdepth to
  1246.   zero.
  1247. */
  1248.  
  1249. {
  1250.   short ok, tmp;
  1251.   unsigned short mv;
  1252.   char s[80];
  1253.  
  1254.   ok = flag.quit = false;
  1255.   player = opponent;
  1256.   ShowSidetomove ();
  1257.   ft = 0;
  1258.   if (hint > 0 && !flag.easy && Book == NULL)
  1259.     {
  1260.       fflush (stdout);
  1261.       time0 = time ((long *) 0);
  1262.       algbr ((short) hint >> 8, (short) hint & 0xFF, false);
  1263.       strcpy (s, mvstr[0]);
  1264.       tmp = epsquare;
  1265.       if (VerifyMove (s, 1, &mv))
  1266.     {
  1267.       ShowPrompt ();
  1268.       SelectMove (computer, 2);
  1269.       (void) VerifyMove (mvstr[0], 2, &mv);
  1270.       if (Sdepth > 0)
  1271.         Sdepth--;
  1272.     }
  1273.       ft = time ((long *) 0) - time0;
  1274.       epsquare = tmp;
  1275.     }
  1276.   signal (SIGINT, Die);
  1277. #ifndef MSDOS
  1278.   signal (SIGQUIT, Die);
  1279. #endif /* MSDOS */
  1280.   while (!(ok || flag.quit))
  1281.     {
  1282.       ShowPrompt ();
  1283.       scanz ("%s", s);
  1284.       player = opponent;
  1285.       ok = VerifyMove (s, 0, &mv);
  1286.       if (ok && mv != hint)
  1287.     {
  1288.       Sdepth = 0;
  1289.       ft = 0;
  1290.     }
  1291.       if (*s == '\0')
  1292.     UpdateDisplay (0, 0, 1, 0);
  1293.       if (strcmp (s, "bd") == 0)
  1294.     {
  1295.       ClrScreen ();
  1296.       UpdateDisplay (0, 0, 1, 0);
  1297.     }
  1298.       if ((strcmp (s, "quit") == 0) || (strcmp (s, "exit") == 0))
  1299.     flag.quit = true;
  1300.       if (strcmp (s, "post") == 0)
  1301.     flag.post = !flag.post;
  1302.       if (strcmp (s, "edit") == 0)
  1303.     EditBoard ();
  1304.       if (strcmp (s, "go") == 0)
  1305.     ok = true;
  1306.       if (strcmp (s, "help") == 0)
  1307.     help ();
  1308.       if (strcmp (s, "force") == 0)
  1309.     flag.force = !flag.force;
  1310.       if (strcmp (s, "book") == 0)
  1311.     Book = NULL;
  1312.       if (strcmp (s, "undo") == 0 && GameCnt > 0)
  1313.     Undo ();
  1314.       if (strcmp (s, "new") == 0)
  1315.     NewGame ();
  1316.       if (strcmp (s, "list") == 0)
  1317.     ListGame ();
  1318.       if (strcmp (s, "level") == 0)
  1319.     SelectLevel ();
  1320.       if (strcmp (s, "hash") == 0)
  1321.     flag.hash = !flag.hash;
  1322.       if (strcmp (s, "beep") == 0)
  1323.     flag.beep = !flag.beep;
  1324.       if (strcmp (s, "Awindow") == 0)
  1325.     ChangeAlphaWindow ();
  1326.       if (strcmp (s, "Bwindow") == 0)
  1327.     ChangeBetaWindow ();
  1328.       if (strcmp (s, "hint") == 0)
  1329.     GiveHint ();
  1330.       if (strcmp (s, "both") == 0)
  1331.     {
  1332.       flag.bothsides = !flag.bothsides;
  1333.       Sdepth = 0;
  1334.       SelectMove (opponent, 1);
  1335.       ok = true;
  1336.     }
  1337.       if (strcmp (s, "reverse") == 0)
  1338.     {
  1339.       flag.reverse = !flag.reverse;
  1340.       ClrScreen ();
  1341.       UpdateDisplay (0, 0, 1, 0);
  1342.     }
  1343.       if (strcmp (s, "switch") == 0)
  1344.     {
  1345.       computer = otherside[computer];
  1346.       opponent = otherside[opponent];
  1347.       flag.force = false;
  1348.       Sdepth = 0;
  1349.       ok = true;
  1350.     }
  1351.       if (strcmp (s, "white") == 0)
  1352.     {
  1353.       computer = white;
  1354.       opponent = black;
  1355.       ok = true;
  1356.       flag.force = false;
  1357.       Sdepth = 0;
  1358.     }
  1359.       if (strcmp (s, "black") == 0)
  1360.     {
  1361.       computer = black;
  1362.       opponent = white;
  1363.       ok = true;
  1364.       flag.force = false;
  1365.       Sdepth = 0;
  1366.     }
  1367.       if (strcmp (s, "remove") == 0 && GameCnt > 1)
  1368.     {
  1369.       Undo ();
  1370.       Undo ();
  1371.     }
  1372.       if (strcmp (s, "get") == 0)
  1373.     GetGame ();
  1374.       if (strcmp (s, "save") == 0)
  1375.     SaveGame ();
  1376.       if (strcmp (s, "depth") == 0)
  1377.     ChangeSearchDepth ();
  1378.       if (strcmp (s, "random") == 0)
  1379.     dither = 6;
  1380.       if (strcmp (s, "easy") == 0)
  1381.     flag.easy = !flag.easy;
  1382.       if (strcmp (s, "contempt") == 0)
  1383.     SetContempt ();
  1384.       if (strcmp (s, "xwndw") == 0)
  1385.     ChangeXwindow ();
  1386.       if (strcmp (s, "test") == 0)
  1387.     {
  1388.           ShowMessage("Testing MoveList Speed");
  1389.       TestSpeed (MoveList);
  1390.           ShowMessage("Testing CaptureList Speed");
  1391.       TestSpeed (CaptureList);
  1392.     }
  1393.       if (strcmp (s, "p") == 0)
  1394.     ShowPostnValues ();
  1395.       if (strcmp (s, "debug") == 0)
  1396.     DoDebug ();
  1397.     }
  1398.  
  1399.   ClearMessage ();
  1400.   ElapsedTime (1);
  1401.   if (flag.force)
  1402.     {
  1403.       computer = opponent;
  1404.       opponent = otherside[computer];
  1405.     }
  1406.   signal (SIGINT, TerminateSearch);
  1407. #ifndef MSDOS
  1408.   signal (SIGQUIT, TerminateSearch);
  1409. #endif /* MSDOS */
  1410. }
  1411.